# coding=UTF-8
__author__ = 'Administrator'

import argparse

from TempleteMethod import func_dict
from generator import RuleGenerator
from getBackgroud import *
from readData import *
from teamconfig import team_short_name
from template import Template
from util import *
import datetime


def main(news_id, playbyplay_path='', recap_path='', boxscore_path=''):
    parser = argparse.ArgumentParser(description="obtain the id of the news")
    parser.add_argument("-n", "--news_id", type=str, default=153356, help="")
    parser.add_argument("-p", "--txt_path", type=str, default='D:\\WriteBot\\untitled\\', help="")
    args = parser.parse_args()
    news_id = args.news_id

    txt_path = args.txt_path
    R = RuleGenerator()
    # 获得指定id的比赛信息
    gameInfo, script, player_data_guest, player_data_host = loadtextlive(news_id, playbyplay_path, recap_path,
                                                                         boxscore_path)
    quarter1 = []
    quarter2 = []
    quarter3 = []
    quarter4 = []
    index = 1
    teams = re.search(r'（(.*)）', script[0]).group(1)
    team_a = teams.split('-')[0]  # 客队
    team_b = teams.split('-')[1]  # 主队
    has_ot = False
    for s in script[1:]:
        if s == '1结束':
            index = 2
            continue
        if s == '2结束':
            index = 3
            continue
        if s == '3结束':
            index = 4
            continue
        if index == 1:
            quarter1.append(s)
        if index == 2:
            quarter2.append(s)
        if index == 3:
            quarter3.append(s)
        if index == 4:
            quarter4.append(s)
    total_event1, point_event1, point_event_a1, point_event_b1, score_event_a1, score_event_b1, score_event1, miss_event_a1, miss_event_b1, miss_event1, reb_event_a1, reb_event_b1, error_event_a1, error_event_b1, foul_event_a1, foul_event_b1, adjust_event_a1, adjust_event_b1, stop_a1, stop_b1, stop1 = R.analyze_one_quarter(
        quarter1, team_a, team_b)
    total_event2, point_event2, point_event_a2, point_event_b2, score_event_a2, score_event_b2, score_event2, miss_event_a2, miss_event_b2, miss_event2, reb_event_a2, reb_event_b2, error_event_a2, error_event_b2, foul_event_a2, foul_event_b2, adjust_event_a2, adjust_event_b2, stop_a2, stop_b2, stop2 = R.analyze_one_quarter(
        quarter2, team_a, team_b)
    total_event3, point_event3, point_event_a3, point_event_b3, score_event_a3, score_event_b3, score_event3, miss_event_a3, miss_event_b3, miss_event3, reb_event_a3, reb_event_b3, error_event_a3, error_event_b3, foul_event_a3, foul_event_b3, adjust_event_a3, adjust_event_b3, stop_a3, stop_b3, stop3 = R.analyze_one_quarter(
        quarter3, team_a, team_b)
    total_event4, point_event4, point_event_a4, point_event_b4, score_event_a4, score_event_b4, score_event4, miss_event_a4, miss_event_b4, miss_event4, reb_event_a4, reb_event_b4, error_event_a4, error_event_b4, foul_event_a4, foul_event_b4, adjust_event_a4, adjust_event_b4, stop_a4, stop_b4, stop4 = R.analyze_one_quarter(
        quarter4, team_a, team_b)

    #############################################
    # TODO gametype 后面会根据比赛趋势来修改
    '''
    gametype=1:最后比赛结束时分差小于5分
    gametype=2:最后比赛结束时分差大于5分小于10分
    gametype=3:最后比赛结束时分差大于10分
    '''
    # 得到比赛程度描述
    gamedesc, gametype = R.get_game_description(point_event4)
    #############################################

    quarter1_s = []  # 第一节的特殊事件
    quarter2_s = []  # 第二节的特殊事件
    quarter3_s = []  # 第三节的特殊事件
    quarter4_s = []  # 第四节的特殊事件

    if point_event1[-1][0] > 0:
        # quarter1_s.append(dict[0][0] + '得到' + team_a + '最高分' + str(dict[0][1]) + '分帮助球队领先')
        end1 = team_a + '领先' + team_b + str(point_event1[-1][0]) + '分。'
    elif point_event1[-1][0] < 0:
        # quarter1_s.append(dict4[0][0] + '得到' + team_b + '最高分' + str(dict4[0][1]) + '分帮助球队领先')
        end1 = team_b + '领先' + team_a + str(-point_event1[-1][0]) + '分。'
    else:
        # quarter1_s.append(dict[0][0] + '得到' + team_a + '最高分' + ',' + dict4[0][0] + '得到' + team_b + '最高分,双方你来我往')
        end1 = '双方战平。'

    if point_event2[-1][0] > 0:
        # quarter2_s.append(dict2[0][0] + '得到' + team_a + '最高分' + str(dict2[0][1]) + '分帮助球队领先')
        end2 = team_a + '领先' + team_b + str(point_event2[-1][0]) + '分。'
    elif point_event2[-1][0] < 0:
        # quarter2_s.append(dict3_b[0][0] + '得到' + team_b + '最高分' + str(dict3_b[0][1]) + '分帮助球队领先')
        end2 = team_b + '领先' + team_a + str(-point_event2[-1][0]) + '分。'
    else:
        # quarter2_s.append(dict2[0][0] + '得到' + team_a + '最高分' + ',' + dict3_b[0][0] + '得到' + team_b + '最高分')
        end2 = '双方战平。'

    if point_event3[-1][0] > 0:
        # quarter3_s.append(dict3_a[0][0] + '得到' + team_a + '最高分' + str(dict3_a[0][1]) + '分帮助球队领先')
        end3 = team_a + '领先' + team_b + str(point_event3[-1][0]) + '分。'
    elif point_event3[-1][0] < 0:
        # quarter3_s.append(dict2_b[0][0] + '得到' + team_b + '最高分' + str(dict2_b[0][1]) + '分帮助球队领先')
        end3 = team_b + '领先' + team_a + str(-point_event3[-1][0]) + '分。'
    else:
        # quarter3_s.append(dict3_a[0][0] + '得到' + team_a + '最高分' + ',' + dict2_b[0][0] + '得到' + team_b + '最高分')
        end3 = '双方战平。'

    if point_event4[-1][0] > 0:
        # quarter4_s.append(dict4_a[0][0] + '得到' + team_a + '最高分' + str(dict4_a[0][1]) + '分，')
        end4 = team_a + '战胜' + team_b + '。'
    elif point_event4[-1][0] < 0:
        # quarter4_s.append(dict1_b[0][0] + '得到' + team_b + '最高分' + str(dict1_b[0][1]) + '分，')
        end4 = team_b + '战胜' + team_a + '。'
    else:
        # quarter4_s.append(dict4_a[0][0] + '得到' + team_a + '最高分' + dict1_b[0][0] + '得到' + team_b + '最高分')
        end4 = '双方战平,进入加时。'
    # team_a_performance,team_b_performance=get_team_performance(team_a,team_b)

    ####lynn 时间方式要修改
    gtime = gameInfo.split(' ')[0].split('：')[1]
    temp_date = re.findall('([0-9]+)年([0-9]+)月([0-9]+)日', gtime)

    # index = temp_date[0][2]
    # if int(index) <= 10:
    #     # index = '0' + str(int(index) - 1)
    #     index = '0' + str(int(index))  # lynn
    # else:
    #     # index = str(int(index) - 1)
    #     index = str(int(index))  # lynn
    # t = temp_date[0][0] + '-' + temp_date[0][1] + '-' + index

    t = (datetime.datetime(int(temp_date[0][0]), int(temp_date[0][1]), int(temp_date[0][2])) + datetime.timedelta(
        -1)).strftime("%Y-%m-%d")

    try:
        ####stat-nba官网关闭！！！###############
        team_a_performance, team_b_performance = get_team_comparison2(team_short_name[team_a], team_short_name[team_b],
                                                                      t)
        if int(team_a_performance.split('胜')[0]) > int(team_b_performance.split('胜')[0]):
            better_team = team_a + '战绩占优。'
        elif int(team_a_performance.split('胜')[0]) < int(team_b_performance.split('胜')[0]):
            better_team = team_b + '战绩占优。'
        else:
            better_team = '双方旗鼓相当。'
        # news_postfix = '\n'.join(label_news.split('###')[2:-1]) #lynn去掉
        #########################
    except:
        print('')
    start_time1 = point_event1[0][1]
    draw_time1 = None
    end_time1 = score_event1[-1][-1]
    a_start1 = point_event1[0][0]
    a_lead1 = 0
    a_lead_time1 = None
    a_end1 = point_event1[-1][0]
    b_start1 = -point_event1[0][0]
    b_lead1 = 0
    b_lead_time1 = None
    b_end1 = -point_event1[-1][0]

    start_time2 = point_event2[0][1]
    draw_time2 = None
    end_time2 = score_event2[-1][-1]
    a_start2 = point_event2[0][0]
    a_lead2 = 0
    a_lead_time2 = None
    a_end2 = point_event2[-1][0]
    b_start2 = -point_event2[0][0]
    b_lead2 = 0
    b_lead_time2 = None
    b_end2 = -point_event2[-1][0]

    start_time3 = point_event3[0][1]
    draw_time3 = None
    end_time3 = score_event3[-1][-1]
    a_start3 = point_event3[0][0]
    a_lead3 = 0
    a_lead_time3 = None
    a_end3 = point_event3[-1][0]
    b_start3 = -point_event3[0][0]
    b_lead3 = 0
    b_lead_time3 = None
    b_end3 = -point_event3[-1][0]

    start_time4 = point_event4[0][1]
    draw_time4 = None
    end_time4 = score_event4[-1][-1]
    a_start4 = point_event4[0][0]
    a_lead4 = 0
    a_lead_time4 = None
    a_end4 = point_event4[-1][0]
    b_start4 = -point_event4[0][0]
    b_lead4 = 0
    b_lead_time4 = None
    b_end4 = -point_event4[-1][0]
    for p in point_event1:
        if p[0] > 0:
            if p[0] > a_lead1:
                a_lead1 = p[0]
                a_lead_time1 = p[1]
        elif p[0] < 0:
            if -p[0] > b_lead1:
                b_lead1 = -p[0]
                b_lead_time1 = p[1]
    for p in point_event2:
        if p[0] > 0:
            if p[0] > a_lead2:
                a_lead2 = p[0]
                a_lead_time2 = p[1]
        elif p[0] < 0:
            if -p[0] > b_lead2:
                b_lead2 = -p[0]
                b_lead_time2 = p[1]
    for p in point_event3:
        if p[0] > 0:
            if p[0] > a_lead3:
                a_lead3 = p[0]
                a_lead_time3 = p[1]
        elif p[0] < 0:
            if -p[0] > b_lead3:
                b_lead3 = -p[0]
                b_lead_time3 = p[1]
    for p in point_event4:
        if p[0] > 0:
            if p[0] > a_lead4:
                a_lead4 = p[0]
                a_lead_time4 = p[1]
        elif p[0] < 0:
            if -p[0] > b_lead4:
                b_lead4 = -p[0]
                b_lead_time4 = p[1]

    if a_lead1 > 0 and b_lead1 > 0:
        draw_t1 = []
        reverse_t1 = []
        pre = 0
        if R.process_time(a_lead_time1) > R.process_time(b_lead_time1):
            for p in point_event1:
                if R.process_time(p[1]) <= R.process_time(
                        a_lead_time1) and R.process_time(p[1]) >= R.process_time(b_lead_time1):
                    if pre != 0 and p[0] == 0:
                        draw_t1.append(p[1])
                    if pre > 0 and p[0] < 0:
                        reverse_t1.append(p[1])
                    pre = p[0]
        else:
            for p in point_event1:
                if R.process_time(p[1]) >= R.process_time(
                        a_lead_time1) and R.process_time(p[1]) <= R.process_time(b_lead_time1):
                    if pre != 0 and p[0] == 0:
                        draw_t1.append(p[1])
                    if pre < 0 and p[0] > 0:
                        reverse_t1.append(p[1])
                    pre = p[0]
        if len(draw_t1) != 0:
            draw_time1 = draw_t1[int(len(draw_t1) / 2)]  ##lynn
        else:
            reverse_time1 = reverse_t1[int(len(reverse_t1) / 2)]  ##lynn
    if a_lead2 > 0 and b_lead2 > 0:
        draw_t2 = []
        reverse_t2 = []
        pre = 0
        if R.process_time(a_lead_time2) > R.process_time(b_lead_time2):
            for p in point_event2:
                if R.process_time(p[1]) <= R.process_time(
                        a_lead_time2) and R.process_time(p[1]) >= R.process_time(b_lead_time2):
                    if pre != 0 and p[0] == 0:
                        draw_t2.append(p[1])
                    if pre > 0 and p[0] < 0:
                        reverse_t2.append(p[1])
                    pre = p[0]
        else:
            for p in point_event2:
                if R.process_time(p[1]) >= R.process_time(
                        a_lead_time2) and R.process_time(p[1]) <= R.process_time(b_lead_time2):
                    if pre != 0 and p[0] == 0:
                        draw_t2.append(p[1])
                    if pre < 0 and p[0] > 0:
                        reverse_t2.append(p[1])
                    pre = p[0]
        if len(draw_t2) != 0:
            draw_time2 = draw_t2[int(len(draw_t2) / 2)]  ##lynn
        else:
            reverse_time2 = reverse_t2[int(len(reverse_t2) / 2)]  ##lynn
    if a_lead3 > 0 and b_lead3 > 0:
        draw_t3 = []
        reverse_t3 = []
        pre = 0
        if R.process_time(a_lead_time3) > R.process_time(b_lead_time3):
            for p in point_event3:
                if R.process_time(p[1]) <= R.process_time(
                        a_lead_time3) and R.process_time(p[1]) >= R.process_time(
                    b_lead_time3):
                    if pre != 0 and p[0] == 0:
                        draw_t3.append(p[1])
                    if pre > 0 and p[0] < 0:
                        reverse_t3.append(p[1])
                    pre = p[0]
        else:
            for p in point_event3:
                if R.process_time(p[1]) >= R.process_time(
                        a_lead_time3) and R.process_time(p[1]) <= R.process_time(b_lead_time3):
                    if pre != 0 and p[0] == 0:
                        draw_t3.append(p[1])
                    if pre < 0 and p[0] > 0:
                        reverse_t3.append(p[1])
                    pre = p[0]
        if len(draw_t3) != 0:
            draw_time3 = draw_t3[int(len(draw_t3) / 2)]  ##lynn
        else:
            reverse_time3 = reverse_t3[int(len(reverse_t3) / 2)]  ##lynn
    if a_lead4 > 0 and b_lead4 > 0:
        draw_t4 = []
        reverse_t4 = []
        pre = 0
        if R.process_time(a_lead_time4) > R.process_time(b_lead_time4):
            for p in point_event4:
                if R.process_time(p[1]) <= R.process_time(
                        a_lead_time4) and R.process_time(p[1]) >= R.process_time(
                    b_lead_time4):
                    if pre != 0 and p[0] == 0:
                        draw_t4.append(p[1])
                    if pre > 0 and p[0] < 0:
                        reverse_t4.append(p[1])
                    pre = p[0]
        else:
            for p in point_event4:
                if R.process_time(p[1]) >= R.process_time(
                        a_lead_time4) and R.process_time(p[1]) <= R.process_time(b_lead_time4):
                    if pre != 0 and p[0] == 0:
                        draw_t4.append(p[1])
                    if pre < 0 and p[0] > 0:
                        reverse_t4.append(p[1])
                    pre = p[0]
        if len(draw_t4) != 0:
            draw_time4 = draw_t4[int(len(draw_t4) / 2)]  ##lynn
        else:
            reverse_time4 = reverse_t4[int(len(reverse_t4) / 2)]  ##lynn

    lead_player_a1 = ''
    lead_event_a1 = ''
    lead_player_b1 = ''
    lead_event_b1 = ''
    lead_player_a2 = ''
    lead_event_a2 = ''
    lead_player_b2 = ''
    lead_event_b2 = ''
    lead_player_a3 = ''
    lead_event_a3 = ''
    lead_player_b3 = ''
    lead_event_b3 = ''
    lead_player_a4 = ''
    lead_event_a4 = ''
    lead_player_b4 = ''
    lead_event_b4 = ''

    for s in score_event_a1:
        if s[-1] == a_lead_time1:
            lead_event_a1 = s[3]
            lead_player_a1 = s[1]
    for s in score_event_b1:
        if s[-1] == b_lead_time1:
            lead_event_b1 = s[3]
            lead_player_b1 = s[1]

    for s in score_event_a2:
        if s[-1] == a_lead_time2:
            lead_event_a2 = s[3]
            lead_player_a2 = s[1]

    for s in score_event_b2:
        if s[-1] == b_lead_time2:
            lead_event_b2 = s[3]
            lead_player_b2 = s[1]

    for s in score_event_a3:
        if s[-1] == a_lead_time3:
            lead_event_a3 = s[3]
            lead_player_a3 = s[1]
    for s in score_event_b3:
        if s[-1] == b_lead_time3:
            lead_event_b3 = s[3]
            lead_player_b3 = s[1]

    for s in score_event_a4:
        if s[-1] == a_lead_time4:
            lead_event_a4 = s[3]
            lead_player_a4 = s[1]
    for s in score_event_b4:
        if s[-1] == b_lead_time4:
            lead_event_b4 = s[3]
            lead_player_b4 = s[1]

    '''
    以客队为主视角
    1:开始平，先领先（分差大于0）后落后（分差小于0）,结束时领先（领先分数小于刚开始领先分数）
    2:开始平，先领先（分差大于0）后落后（分差小于0）,结束时落后（落后分数小于刚开始落后分数）
    3:开始平，先领先（分差大于0）后落后（分差小于0）,结束时落后（落后分数等于刚开始落后分数）
    4:开始平，先领先（分差大于0）后落后（分差小于0）,结束时落后（结束时分差落后最多）
    5:开始平，先领先（分差大于0）后落后（分差小于0）,结束时打平（分差等于0）
    6:开始平，先落后（分差小于0）再领先（分差大于0）,结束时领先（领先分数小于刚开始领先分数）
    7:开始平，先落后（分差小于0）再领先（分差大于0）,结束时领先（领先分数等于刚开始领先分数）
    8:开始平，先落后（分差小于0）再领先（分差大于0）,结束时领先（结束时领先最大）
    9:开始平，先落后（分差小于0）再领先（分差大于0）,结束时落后（落后分数小于刚开始落后分数）
    10:开始平，先落后（分差小于0）再领先（分差大于0）,结束时平（分差等于0）
    11:开始平，一直领先（分差一直大于0）,结束时领先（分差小于之前领先分差）
    12:开始平，一直领先（分差一直大于0）,结束时领先（结束时分差最大）
    13:开始平，一直领先（分差一直大于0）,结束时领先（领先分数等于刚开始领先分数） 
    14:开始平，一直落后（分差一直小于0）,结束时落后（分差小于之前落后分差）
    15:开始平，一直落后（分差一直小于0）,结束时落后（结束时分差最大）
    16:开始平，一直落后（分差一直小于0）,结束时落后（落后分数等于刚开始落后分数）
    17:开始领先，先领先（分差大于开始分差）后被追平(分差小于0),然后落后（分差小于0）,结束时领先（领先分数小于刚开始领先分数）
    18:开始领先，先领先（分差大于开始分差）后被追平(分差小于0),然后落后（分差小于0）,结束时落后（落后分数小于刚开始落后分数）
    19:开始领先，先领先（分差大于开始分差）后被追平(分差小于0),然后落后（分差小于0）,结束时落后（落后分数等于刚开始落后分数）
    20:开始领先，先领先（分差大于开始分差）后被追平(分差小于0),然后落后（分差小于0）,结束时落后（结束时分差落后最多）
    21:开始领先，先领先（分差大于开始分差）后被追平(分差小于0),然后落后（分差小于0）,结束时打平
    22:开始领先，先领先（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再落后（分差小于0）,结束时领先（领先分数小于刚开始领先分数）
    23:开始领先，先领先（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再落后（分差小于0）,结束时落后（落后分数小于刚开始落后分数）
    24:开始领先，先领先（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再落后（分差小于0）,结束时落后（落后分数等于刚开始落后分数）
    25:开始领先，先领先（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再落后（分差小于0）,结束时落后（结束时分差落后最多）
    26:开始领先，先领先（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再落后（分差小于0）,结束时打平
    27:开始领先，先领先（分差小于开始分差），后被追平(分差等于0)，再落后（分差小于0）,再领先（分差大于刚开始领先分数）,结束时领先（领先分数小于刚开始领先分数）
    28:开始领先，先领先（分差小于开始分差），后被追平(分差等于0)，再落后（分差小于0）,再领先（分差大于刚开始领先分数）,结束时领先（领先分数等于刚开始领先分数）
    29:开始领先，先领先（分差小于开始分差），后被追平(分差等于0)，再落后（分差小于0）,再领先（分差大于刚开始领先分数）,结束时领先（结束时领先最大）
    30:开始领先，先领先（分差小于开始分差），后被追平(分差等于0)，再落后（分差小于0）,再领先（分差大于刚开始领先分数）,结束时落后（落后分数小于刚开始落后分数）
    31:开始领先，先领先（分差小于开始分差），后被追平(分差等于0)，再落后（分差小于0）,再领先（分差大于刚开始领先分数）,结束时打平
    32:开始领先，一直领先，结束时领先（刚开始领先分差最大）
    33:开始领先，一直领先（最大分差大于开始分差，大于结束分差）,结束时领先（分差小于之前分差）
    34:开始领先，一直领先，结束时领先（分差等于之前分差）
    35:开始领先，一直领先，结束时领先（结束时分差最大）
    36:开始落后，一直落后(最大分差等于开始分差)，结束时落后
    37:开始落后，一直落后(最大分差大于于开始分差)，结束时落后（结束时分差小于之前分差）
    38:开始落后，一直落后(最大分差等于结束分差)，结束时落后（结束时分差等于之前分差）
    39:开始落后，一直落后(最大分差等于结束分差)，结束时落后（结束时落后最大）
    40:开始落后，先落后（分差大于开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时领先（领先分数小于刚开始领先分数）
    41:开始落后，先落后（分差大于开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时领先（领先分数等于刚开始领先分数）
    42:开始落后，先落后（分差大于开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时领先（结束时领先最大）
    43:开始落后，先落后（分差大于开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时落后（落后分数小于刚开始落后分数
    44:开始落后，先落后（分差大于开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时打平
    45:开始落后，先落后（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时领先（领先分数小于刚开始领先分数）
    46:开始落后，先落后（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时领先（领先分数等于刚开始领先分数）
    47:开始落后，先落后（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时领先（结束时领先最大）
    48:开始落后，先落后（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时落后（落后分数小于刚开始落后分数
    49:开始落后，先落后（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时打平
    50:开始落后，先落后（分差小于开始分差），后被追平(分差等于0)，再领先（分差大于0）,再落后（分差大于刚开始落后分差）,结束时领先（领先分数小于刚开始领先分数）
    51:开始落后，先落后（分差小于开始分差），后被追平(分差等于0)，再领先（分差大于0）,再落后（分差大于刚开始落后分差）,结束时落后（落后分数小于刚开始落后分数）
    52:开始落后，先落后（分差小于开始分差），后被追平(分差等于0)，再领先（分差大于0）,再落后（分差大于刚开始落后分差）,结束时落后（落后分数等于刚开始落后分数）
    53:开始落后，先落后（分差小于开始分差），后被追平(分差等于0)，再领先（分差大于0）,再落后（分差大于刚开始落后分差）,结束时落后（结束时分差落后最多）        
    54:开始落后，先落后（分差小于开始分差），后被追平(分差等于0)，再领先（分差大于0）,再落后（分差大于刚开始落后分差）,结束时打平


    '''
    ###################################判断一节比赛的趋势#####################
    trend_dict = {
        1: '开始平，先领先（分差大于0）后落后（分差小于0）,结束时领先（领先分数小于刚开始领先分数）',
        2: '开始平，先领先（分差大于0）后落后（分差小于0）,结束时落后（落后分数小于刚开始落后分数）',
        3: '开始平，先领先（分差大于0）后落后（分差小于0）,结束时落后（落后分数等于刚开始落后分数）',
        4: '开始平，先领先（分差大于0）后落后（分差小于0）,结束时落后（结束时分差落后最多）',
        5: '开始平，先领先（分差大于0）后落后（分差小于0）,结束时打平（分差等于0）',
        6: '开始平，先落后（分差小于0）再领先（分差大于0）,结束时领先（领先分数小于刚开始领先分数）',
        7: '开始平，先落后（分差小于0）再领先（分差大于0）,结束时领先（领先分数等于刚开始领先分数）',
        8: '开始平，先落后（分差小于0）再领先（分差大于0）,结束时领先（结束时领先最大）',
        9: '开始平，先落后（分差小于0）再领先（分差大于0）,结束时落后（落后分数小于刚开始落后分数）',
        10: '开始平，先落后（分差小于0）再领先（分差大于0）,结束时平（分差等于0）',
        11: '开始平，一直领先（分差一直大于0）,结束时领先（分差小于之前领先分差）',
        12: '开始平，一直领先（分差一直大于0）,结束时领先（结束时分差最大）',
        13: '开始平，一直领先（分差一直大于0）,结束时领先（领先分数等于刚开始领先分数）',
        14: '开始平，一直落后（分差一直小于0）,结束时落后（分差小于之前落后分差）',
        15: '开始平，一直落后（分差一直小于0）,结束时落后（结束时分差最大）',
        16: '开始平，一直落后（分差一直小于0）,结束时落后（落后分数等于刚开始落后分数）',
        17: '开始领先，先领先（分差大于开始分差）后被追平(分差小于0),然后落后（分差小于0）,结束时领先（领先分数小于刚开始领先分数）',
        18: '开始领先，先领先（分差大于开始分差）后被追平(分差小于0),然后落后（分差小于0）,结束时落后（落后分数小于刚开始落后分数）',
        19: '开始领先，先领先（分差大于开始分差）后被追平(分差小于0),然后落后（分差小于0）,结束时落后（落后分数等于刚开始落后分数）',
        20: '开始领先，先领先（分差大于开始分差）后被追平(分差小于0),然后落后（分差小于0）,结束时落后（结束时分差落后最多）',
        21: '开始领先，先领先（分差大于开始分差）后被追平(分差小于0),然后落后（分差小于0）,结束时打平',
        22: '开始领先，先领先（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再落后（分差小于0）,结束时领先（领先分数小于刚开始领先分数）',
        23: '开始领先，先领先（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再落后（分差小于0）,结束时落后（落后分数小于刚开始落后分数）',
        24: '开始领先，先领先（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再落后（分差小于0）,结束时落后（落后分数等于刚开始落后分数）',
        25: '开始领先，先领先（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再落后（分差小于0）,结束时落后（结束时分差落后最多）',
        26: '开始领先，先领先（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再落后（分差小于0）,结束时打平',
        27: '开始领先，先领先（分差小于开始分差），后被追平(分差等于0)，再落后（分差小于0）,再领先（分差大于刚开始领先分数）,结束时领先（领先分数小于刚开始领先分数）',
        28: '开始领先，先领先（分差小于开始分差），后被追平(分差等于0)，再落后（分差小于0）,再领先（分差大于刚开始领先分数）,结束时领先（领先分数等于刚开始领先分数）',
        29: '开始领先，先领先（分差小于开始分差），后被追平(分差等于0)，再落后（分差小于0）,再领先（分差大于刚开始领先分数）,结束时领先（结束时领先最大）',
        30: '开始领先，先领先（分差小于开始分差），后被追平(分差等于0)，再落后（分差小于0）,再领先（分差大于刚开始领先分数）,结束时落后（落后分数小于刚开始落后分数）',
        31: '开始领先，先领先（分差小于开始分差），后被追平(分差等于0)，再落后（分差小于0）,再领先（分差大于刚开始领先分数）,结束时打平',
        32: '开始领先，一直领先，结束时领先（刚开始领先分差最大）',
        33: '开始领先，一直领先（最大分差大于开始分差，大于结束分差）,结束时领先（分差小于之前分差）',
        34: '开始领先，一直领先，结束时领先（分差等于之前分差）',
        35: '开始领先，一直领先，结束时领先（结束时分差最大）',
        36: '开始落后，一直落后(最大分差等于开始分差)，结束时落后',
        37: '开始落后，一直落后(最大分差大于于开始分差)，结束时落后（结束时分差小于之前分差）',
        38: '开始落后，一直落后(最大分差等于结束分差)，结束时落后（结束时分差等于之前分差）',
        39: '开始落后，一直落后(最大分差等于结束分差)，结束时落后（结束时落后最大）',
        40: '开始落后，先落后（分差大于开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时领先（领先分数小于刚开始领先分数）',
        41: '开始落后，先落后（分差大于开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时领先（领先分数等于刚开始领先分数）',
        42: '开始落后，先落后（分差大于开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时领先（结束时领先最大）',
        43: '开始落后，先落后（分差大于开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时落后（落后分数小于刚开始落后分数）',
        44: '开始落后，先落后（分差大于开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时打平',
        45: '开始落后，先落后（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时领先（领先分数小于刚开始领先分数）',
        46: '开始落后，先落后（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时领先（领先分数等于刚开始领先分数）',
        47: '开始落后，先落后（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时领先（结束时领先最大）',
        48: '开始落后，先落后（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时落后（落后分数小于刚开始落后分数',
        49: '开始落后，先落后（分差小于开始分差，最大分差为开始分差），后被追平(分差等于0)，再领先（分差大于0）,结束时打平',
        50: '开始落后，先落后（分差小于开始分差），后被追平(分差等于0)，再领先（分差大于0）,再落后（分差大于刚开始落后分差）,结束时领先（领先分数小于刚开始领先分数）',
        51: '开始落后，先落后（分差小于开始分差），后被追平(分差等于0)，再领先（分差大于0）,再落后（分差大于刚开始落后分差）,结束时落后（落后分数小于刚开始落后分数）',
        52: '开始落后，先落后（分差小于开始分差），后被追平(分差等于0)，再领先（分差大于0）,再落后（分差大于刚开始落后分差）,结束时落后（落后分数等于刚开始落后分数）',
        53: '开始落后，先落后（分差小于开始分差），后被追平(分差等于0)，再领先（分差大于0）,再落后（分差大于刚开始落后分差）,结束时落后（结束时分差落后最多）',
        54: '开始落后，先落后（分差小于开始分差），后被追平(分差等于0)，再领先（分差大于0）,再落后（分差大于刚开始落后分差）,结束时打平'
    }

    trend1 = R.get_quarter_game_trend(end_time1, a_start1, a_lead1, a_lead_time1, a_end1, b_start1, b_lead1,
                                      b_lead_time1, b_end1)
    trend2 = R.get_quarter_game_trend(end_time2, a_start2, a_lead2, a_lead_time2, a_end2, b_start2, b_lead2,
                                      b_lead_time2, b_end2)
    trend3 = R.get_quarter_game_trend(end_time3, a_start3, a_lead3, a_lead_time3, a_end3, b_start3, b_lead3,
                                      b_lead_time3, b_end3)
    trend4 = R.get_quarter_game_trend(end_time4, a_start4, a_lead4, a_lead_time4, a_end4, b_start4, b_lead4,
                                      b_lead_time4, b_end4)
    # print(a_start1, a_lead1, a_lead_time1, b_start1, b_lead1, b_lead_time1, a_end1, b_end1)
    # print(a_start2, a_lead2, a_lead_time2, b_start2, b_lead2, b_lead_time2, a_end2, b_end2)
    # print(a_start3, a_lead3, a_lead_time3, b_start3, b_lead3, b_lead_time3, a_end3, b_end3)
    # print(a_start4, a_lead4, a_lead_time4, b_start4, b_lead4, b_lead_time4, a_end4, b_end4)
    # print('第一节比赛的趋势是：' + str(trend1) + trend_dict[trend1])
    # print('第二节比赛的趋势是：' + str(trend2) + trend_dict[trend2])
    # print('第三节比赛的趋势是：' + str(trend3) + trend_dict[trend3])
    # print('第四节比赛的趋势是：' + str(trend4) + trend_dict[trend4])

    func_dict[trend1](quarter1_s, team_a, a_start1, a_lead1, lead_player_a1, lead_event_a1, a_lead_time1, team_b,
                      b_start1, b_lead1, lead_player_b1, lead_event_b1, b_lead_time1, score_event1, score_event_a1,
                      score_event_b1, a_end1, b_end1)
    func_dict[trend2](quarter2_s, team_a, a_start2, a_lead2, lead_player_a2, lead_event_a2, a_lead_time2, team_b,
                      b_start2,
                      b_lead2, lead_player_b2, lead_event_b2, b_lead_time2, score_event2, score_event_a2,
                      score_event_b2,
                      a_end2, b_end2)
    func_dict[trend3](quarter3_s, team_a, a_start3, a_lead3, lead_player_a3, lead_event_a3, a_lead_time3, team_b,
                      b_start3,
                      b_lead3, lead_player_b3, lead_event_b3, b_lead_time3, score_event3, score_event_a3,
                      score_event_b3,
                      a_end3, b_end3)
    func_dict[trend4](quarter4_s, team_a, a_start4, a_lead4, lead_player_a4, lead_event_a4, a_lead_time4, team_b,
                      b_start4,
                      b_lead4, lead_player_b4, lead_event_b4, b_lead_time4, score_event4, score_event_a4,
                      score_event_b4,
                      a_end4, b_end4)
    #######################################判断比赛趋势####################

    ########################################################################################
    # 旧每节比赛趋势判断。临时使用
    ########################################################################################

    # 通过知识图谱获取背景信息
    g = getInfoFromKnowledgeGraph()
    partition1 = g.getPartition(team_a)
    partition2 = g.getPartition(team_b)
    temp = ''
    if partition1 == u'东部' and partition2 == u'东部':
        temp = Template.game_description2[2]
    elif partition1 == u'西部' and partition2 == u'西部':
        temp = Template.game_description2[0]
    else:
        temp = Template.game_description2[1]
    s1, s2, tag = g.getLastGame(team_a, team_b)
    if s1 > s2 and tag == 0:
        win = team_b
        lose = team_a
    elif s1 < s2 and tag == 0:
        win = team_a
        lose = team_b
    elif s1 > s2 and tag == 1:
        win = team_a
        lose = team_b
    else:
        win = team_b
        lose = team_a

    ######stat-nba时常关闭，需要去除get_team_comparison2信息########
    try:
        news = Template.START.replace('#time', gtime).replace('#f_start1',
                                                              random.choice(Template.f_start1).replace('#主队',
                                                                                                       team_b).replace(
                                                                  '#客队', team_a)) + \
               temp + \
               Template.game_description.replace('#比赛描述', gamedesc) + \
               Template.host_team_description.replace('#主队', team_b).replace('#战绩1', team_b_performance) + ',' + \
               Template.guest_team_description.replace('#客队', team_a).replace('#战绩2', team_a_performance) + \
               better_team + \
               random.choice(Template.last_match).replace('#球队1', win).replace('#球队2', lose) + \
               random.choice(Template.quarter1_start) + \
               quarter1_s[0] + Template.quarter1_end.replace('#结果1', end1) + random.choice(Template.quarter2_start) + \
               quarter2_s[0] + Template.quarter2_end.replace('#结果2', end2) + random.choice(Template.quarter3_start) + \
               quarter3_s[0] + Template.quarter3_end.replace('#结果3', end3) + random.choice(Template.quarter4_start) + \
               quarter4_s[0] + Template.quarter4_end.replace('#结果4', end4)
    except:
        news = Template.START.replace('#time', gtime).replace('#f_start1',
                                                              random.choice(Template.f_start1).replace('#主队',
                                                                                                       team_b).replace(
                                                                  '#客队', team_a)) + \
               temp + \
               Template.game_description.replace('#比赛描述', gamedesc) + \
               random.choice(Template.last_match).replace('#球队1', win).replace('#球队2', lose) + \
               random.choice(Template.quarter1_start) + \
               quarter1_s[0] + Template.quarter1_end.replace('#结果1', end1) + random.choice(Template.quarter2_start) + \
               quarter2_s[0] + Template.quarter2_end.replace('#结果2', end2) + random.choice(Template.quarter3_start) + \
               quarter3_s[0] + Template.quarter3_end.replace('#结果3', end3) + random.choice(Template.quarter4_start) + \
               quarter4_s[0] + Template.quarter4_end.replace('#结果4', end4)
    news = '机器写稿: ' + news
    print(news)
    # R.make_txt_file(news_id, news, txt_path)


if __name__ == '__main__':
    main()
